package mylib.archive.y2012.m08.CPR_Beta_1;

import mylib.dir.FastInputReader;
import mylib.dir.SimpleUtils;

import java.io.PrintWriter;

public class taskA {
    public void solve(int testNumber, FastInputReader in, PrintWriter out) {
        int n = in.nextInt();
        int m = in.nextInt();
        if (n > 6 || n < 4 || n == 5) {
            out.print("Falsification");
        } else {
            int graph[][] = new int[n][n];
            for (int i = 0; i < m; ++i) {
                int x = in.nextInt() - 1;
                int y = in.nextInt() - 1;
                graph[x][y]++;
                graph[y][x]++;
            }
            if (n == 4) {
                int[][] etalone = new int[][]{
                        {0, 1, 1, 1},
                        {1, 0, 1, 1},
                        {1, 1, 0, 1},
                        {1, 1, 1, 0}
                };
                Integer[] perm = SimpleUtils.getOrder(4);
                do {
                    int[][] gg = new int[4][4];
                    for (int i = 0; i < 4; ++i) {
                        for (int j = 0; j < 4; ++j) {
                            gg[perm[i]][perm[j]] += graph[i][j];
                            gg[perm[j]][perm[i]] += graph[i][j];
                        }
                    }
                    for (int i = 0; i < 4; ++i)
                        for (int j = 0; j < 4; ++j)
                            gg[i][j] /= 2;
                    boolean ok = equal(etalone, gg);
                    if (ok) {
                        out.print("Glupov");
                        return;
                    }
                } while (SimpleUtils.nextPermutation(perm));


                etalone = new int[][]{
                        {0, 0, 1, 2},
                        {0, 0, 2, 1},
                        {1, 2, 0, 0},
                        {2, 1, 0, 0}
                };
                perm = SimpleUtils.getOrder(4);
                do {
                    int[][] gg = new int[4][4];
                    for (int i = 0; i < 4; ++i) {
                        for (int j = 0; j < 4; ++j) {
                            gg[perm[i]][perm[j]] += graph[i][j];
                            gg[perm[j]][perm[i]] += graph[i][j];
                        }
                    }
                    for (int i = 0; i < 4; ++i)
                        for (int j = 0; j < 4; ++j)
                            gg[i][j] /= 2;
                    boolean ok = equal(etalone, gg);
                    if (ok) {
                        out.print("Glupov");
                        return;
                    }
                } while (SimpleUtils.nextPermutation(perm));

            } else {
                int[][] etalone = new int[][]{
                        {0, 1, 0, 1, 0, 1},
                        {1, 0, 1, 0, 0, 1},
                        {0, 1, 0, 1, 1, 0},
                        {1, 0, 1, 0, 1, 0},
                        {0, 0, 1, 1, 0, 1},
                        {1, 1, 0, 0, 1, 0}
                };
                Integer[] perm = SimpleUtils.getOrder(6);
                do {
                    int[][] gg = new int[6][6];
                    for (int i = 0; i < 6; ++i) {
                        for (int j = 0; j < 6; ++j) {
                            gg[perm[i]][perm[j]] += graph[i][j];
                            gg[perm[j]][perm[i]] += graph[i][j];
                        }
                    }
                    for (int i = 0; i < 6; ++i)
                        for (int j = 0; j < 6; ++j)
                            gg[i][j] /= 2;
                    boolean ok = equal(etalone, gg);
                    if (ok) {
                        out.print("Glupov");
                        return;
                    }
                } while (SimpleUtils.nextPermutation(perm));
            }
            out.println("Falsification");
        }
    }

    private boolean equal(int[][] etalone, int[][] perm) {
        for (int i = 0; i < etalone.length; ++i)
            for (int j = 0; j < etalone[i].length; ++j)
                if (etalone[i][j] != perm[i][j])
                    return false;
        return true;
    }
}
